home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Outils / Adobe-Air / adobe-air_13.exe / [0] / setup.swf / scripts / mx / effects / EffectInstance.as < prev    next >
Text File  |  2014-03-27  |  10KB  |  379 lines
  1. package mx.effects
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.events.TimerEvent;
  6.    import flash.utils.Timer;
  7.    import flash.utils.getQualifiedClassName;
  8.    import flash.utils.getTimer;
  9.    import mx.core.UIComponent;
  10.    import mx.core.mx_internal;
  11.    import mx.effects.effectClasses.PropertyChanges;
  12.    import mx.events.EffectEvent;
  13.    import mx.events.FlexEvent;
  14.    
  15.    use namespace mx_internal;
  16.    
  17.    public class EffectInstance extends EventDispatcher implements IEffectInstance
  18.    {
  19.       
  20.       mx_internal static const VERSION:String = "3.0.0.0";
  21.        
  22.       
  23.       private var _hideFocusRing:Boolean;
  24.       
  25.       private var delayStartTime:Number = 0;
  26.       
  27.       mx_internal var stopRepeat:Boolean = false;
  28.       
  29.       private var playCount:int = 0;
  30.       
  31.       private var _repeatCount:int = 0;
  32.       
  33.       private var _suspendBackgroundProcessing:Boolean = false;
  34.       
  35.       mx_internal var delayTimer:Timer;
  36.       
  37.       private var _triggerEvent:Event;
  38.       
  39.       private var _effectTargetHost:IEffectTargetHost;
  40.       
  41.       mx_internal var parentCompositeEffectInstance:EffectInstance;
  42.       
  43.       mx_internal var durationExplicitlySet:Boolean = false;
  44.       
  45.       private var _effect:IEffect;
  46.       
  47.       private var _target:Object;
  48.       
  49.       mx_internal var hideOnEffectEnd:Boolean = false;
  50.       
  51.       private var _startDelay:int = 0;
  52.       
  53.       private var delayElapsedTime:Number = 0;
  54.       
  55.       private var _repeatDelay:int = 0;
  56.       
  57.       private var _propertyChanges:PropertyChanges;
  58.       
  59.       private var _duration:Number = 500;
  60.       
  61.       private var _playReversed:Boolean;
  62.       
  63.       public function EffectInstance(param1:Object)
  64.       {
  65.          super();
  66.          this.target = param1;
  67.       }
  68.       
  69.       public function get playheadTime() : Number
  70.       {
  71.          return Math.max(playCount - 1,0) * duration + Math.max(playCount - 2,0) * repeatDelay + (!!mx_internal::playReversed ? 0 : startDelay);
  72.       }
  73.       
  74.       public function get hideFocusRing() : Boolean
  75.       {
  76.          return _hideFocusRing;
  77.       }
  78.       
  79.       public function stop() : void
  80.       {
  81.          if(mx_internal::delayTimer)
  82.          {
  83.             mx_internal::delayTimer.reset();
  84.          }
  85.          stopRepeat = true;
  86.          finishEffect();
  87.       }
  88.       
  89.       public function finishEffect() : void
  90.       {
  91.          playCount = 0;
  92.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  93.          if(target)
  94.          {
  95.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_END,false,false,this));
  96.          }
  97.          if(target is UIComponent)
  98.          {
  99.             UIComponent(target).effectFinished(this);
  100.          }
  101.          EffectManager.effectFinished(this);
  102.       }
  103.       
  104.       public function set hideFocusRing(param1:Boolean) : void
  105.       {
  106.          _hideFocusRing = param1;
  107.       }
  108.       
  109.       public function finishRepeat() : void
  110.       {
  111.          if(!mx_internal::stopRepeat && playCount != 0 && (playCount < repeatCount || repeatCount == 0))
  112.          {
  113.             if(repeatDelay > 0)
  114.             {
  115.                delayTimer = new Timer(repeatDelay,1);
  116.                delayStartTime = getTimer();
  117.                mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  118.                mx_internal::delayTimer.start();
  119.             }
  120.             else
  121.             {
  122.                play();
  123.             }
  124.          }
  125.          else
  126.          {
  127.             finishEffect();
  128.          }
  129.       }
  130.       
  131.       mx_internal function get playReversed() : Boolean
  132.       {
  133.          return _playReversed;
  134.       }
  135.       
  136.       public function set effect(param1:IEffect) : void
  137.       {
  138.          _effect = param1;
  139.       }
  140.       
  141.       public function get className() : String
  142.       {
  143.          var _loc1_:String = getQualifiedClassName(this);
  144.          var _loc2_:int = _loc1_.indexOf("::");
  145.          if(_loc2_ != -1)
  146.          {
  147.             _loc1_ = _loc1_.substr(_loc2_ + 2);
  148.          }
  149.          return _loc1_;
  150.       }
  151.       
  152.       public function set duration(param1:Number) : void
  153.       {
  154.          durationExplicitlySet = true;
  155.          _duration = param1;
  156.       }
  157.       
  158.       mx_internal function set playReversed(param1:Boolean) : void
  159.       {
  160.          _playReversed = param1;
  161.       }
  162.       
  163.       public function resume() : void
  164.       {
  165.          if(mx_internal::delayTimer && !mx_internal::delayTimer.running && !isNaN(delayElapsedTime))
  166.          {
  167.             mx_internal::delayTimer.delay = !mx_internal::playReversed ? Number(mx_internal::delayTimer.delay - delayElapsedTime) : Number(delayElapsedTime);
  168.             mx_internal::delayTimer.start();
  169.          }
  170.       }
  171.       
  172.       public function get propertyChanges() : PropertyChanges
  173.       {
  174.          return _propertyChanges;
  175.       }
  176.       
  177.       public function set target(param1:Object) : void
  178.       {
  179.          _target = param1;
  180.       }
  181.       
  182.       public function get repeatCount() : int
  183.       {
  184.          return _repeatCount;
  185.       }
  186.       
  187.       mx_internal function playWithNoDuration() : void
  188.       {
  189.          duration = 0;
  190.          repeatCount = 1;
  191.          repeatDelay = 0;
  192.          startDelay = 0;
  193.          startEffect();
  194.       }
  195.       
  196.       public function get startDelay() : int
  197.       {
  198.          return _startDelay;
  199.       }
  200.       
  201.       mx_internal function get actualDuration() : Number
  202.       {
  203.          var _loc1_:Number = NaN;
  204.          if(repeatCount > 0)
  205.          {
  206.             _loc1_ = duration * repeatCount + (repeatDelay * repeatCount - 1) + startDelay;
  207.          }
  208.          return _loc1_;
  209.       }
  210.       
  211.       public function play() : void
  212.       {
  213.          ++playCount;
  214.          dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  215.          if(target)
  216.          {
  217.             target.dispatchEvent(new EffectEvent(EffectEvent.EFFECT_START,false,false,this));
  218.          }
  219.       }
  220.       
  221.       public function get suspendBackgroundProcessing() : Boolean
  222.       {
  223.          return _suspendBackgroundProcessing;
  224.       }
  225.       
  226.       public function get effectTargetHost() : IEffectTargetHost
  227.       {
  228.          return _effectTargetHost;
  229.       }
  230.       
  231.       public function set repeatDelay(param1:int) : void
  232.       {
  233.          _repeatDelay = param1;
  234.       }
  235.       
  236.       public function set propertyChanges(param1:PropertyChanges) : void
  237.       {
  238.          _propertyChanges = param1;
  239.       }
  240.       
  241.       mx_internal function eventHandler(param1:Event) : void
  242.       {
  243.          if(param1.type == FlexEvent.SHOW && mx_internal::hideOnEffectEnd == true)
  244.          {
  245.             hideOnEffectEnd = false;
  246.             param1.target.removeEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  247.          }
  248.       }
  249.       
  250.       public function set repeatCount(param1:int) : void
  251.       {
  252.          _repeatCount = param1;
  253.       }
  254.       
  255.       private function delayTimerHandler(param1:TimerEvent) : void
  256.       {
  257.          mx_internal::delayTimer.reset();
  258.          delayStartTime = NaN;
  259.          delayElapsedTime = NaN;
  260.          play();
  261.       }
  262.       
  263.       public function set suspendBackgroundProcessing(param1:Boolean) : void
  264.       {
  265.          _suspendBackgroundProcessing = param1;
  266.       }
  267.       
  268.       public function set triggerEvent(param1:Event) : void
  269.       {
  270.          _triggerEvent = param1;
  271.       }
  272.       
  273.       public function set startDelay(param1:int) : void
  274.       {
  275.          _startDelay = param1;
  276.       }
  277.       
  278.       public function get effect() : IEffect
  279.       {
  280.          return _effect;
  281.       }
  282.       
  283.       public function set effectTargetHost(param1:IEffectTargetHost) : void
  284.       {
  285.          _effectTargetHost = param1;
  286.       }
  287.       
  288.       public function get target() : Object
  289.       {
  290.          return _target;
  291.       }
  292.       
  293.       public function startEffect() : void
  294.       {
  295.          EffectManager.effectStarted(this);
  296.          if(target is UIComponent)
  297.          {
  298.             UIComponent(target).effectStarted(this);
  299.          }
  300.          if(startDelay > 0 && !mx_internal::playReversed)
  301.          {
  302.             delayTimer = new Timer(startDelay,1);
  303.             delayStartTime = getTimer();
  304.             mx_internal::delayTimer.addEventListener(TimerEvent.TIMER,delayTimerHandler);
  305.             mx_internal::delayTimer.start();
  306.          }
  307.          else
  308.          {
  309.             play();
  310.          }
  311.       }
  312.       
  313.       public function get repeatDelay() : int
  314.       {
  315.          return _repeatDelay;
  316.       }
  317.       
  318.       public function get duration() : Number
  319.       {
  320.          if(!mx_internal::durationExplicitlySet && mx_internal::parentCompositeEffectInstance)
  321.          {
  322.             return mx_internal::parentCompositeEffectInstance.duration;
  323.          }
  324.          return _duration;
  325.       }
  326.       
  327.       public function initEffect(param1:Event) : void
  328.       {
  329.          triggerEvent = param1;
  330.          switch(param1.type)
  331.          {
  332.             case "resizeStart":
  333.             case "resizeEnd":
  334.                if(!mx_internal::durationExplicitlySet)
  335.                {
  336.                   duration = 250;
  337.                }
  338.                break;
  339.             case FlexEvent.HIDE:
  340.                target.setVisible(true,true);
  341.                hideOnEffectEnd = true;
  342.                target.addEventListener(FlexEvent.SHOW,mx_internal::eventHandler);
  343.          }
  344.       }
  345.       
  346.       public function get triggerEvent() : Event
  347.       {
  348.          return _triggerEvent;
  349.       }
  350.       
  351.       public function end() : void
  352.       {
  353.          if(mx_internal::delayTimer)
  354.          {
  355.             mx_internal::delayTimer.reset();
  356.          }
  357.          stopRepeat = true;
  358.          finishEffect();
  359.       }
  360.       
  361.       public function reverse() : void
  362.       {
  363.          if(repeatCount > 0)
  364.          {
  365.             playCount = repeatCount - playCount + 1;
  366.          }
  367.       }
  368.       
  369.       public function pause() : void
  370.       {
  371.          if(mx_internal::delayTimer && mx_internal::delayTimer.running && !isNaN(delayStartTime))
  372.          {
  373.             mx_internal::delayTimer.stop();
  374.             delayElapsedTime = getTimer() - delayStartTime;
  375.          }
  376.       }
  377.    }
  378. }
  379.